/**
 * 工具基类
 * 所有工具模块都应该继承此基类
 */

const EventEmitter = require('events');
const Logger = require('../utils/Logger');

class BaseTool extends EventEmitter {
    constructor(name, displayName) {
        super();
        this.name = name;
        this.displayName = displayName;
        this.isActive = false;
        this.isInitialized = false;
        this.logger = new Logger(`[${displayName}]`);
        this.elements = {};
    }

    /**
     * 初始化工具
     * 子类应该重写此方法
     */
    async initialize() {
        if (this.isInitialized) {
            return;
        }

        try {
            this.logger.info('正在初始化工具...');
            
            // 获取DOM元素
            await this.getDOMElements();
            
            // 设置事件监听器
            this.setupEventListeners();
            
            // 执行自定义初始化逻辑
            await this.onInitialize();
            
            this.isInitialized = true;
            this.logger.success('工具初始化完成');
            
            // 触发初始化完成事件
            this.emit('initialized');
        } catch (error) {
            this.logger.error('工具初始化失败:', error);
            throw error;
        }
    }

    /**
     * 激活工具
     */
    async activate() {
        if (!this.isInitialized) {
            await this.initialize();
        }

        if (this.isActive) {
            return;
        }

        try {
            this.logger.info('正在激活工具...');
            
            // 显示工具面板
            this.showPanel();
            
            // 执行自定义激活逻辑
            await this.onActivate();
            
            this.isActive = true;
            this.logger.info('工具已激活');
            
            // 触发激活事件
            this.emit('activated');
        } catch (error) {
            this.logger.error('工具激活失败:', error);
            throw error;
        }
    }

    /**
     * 停用工具
     */
    async deactivate() {
        if (!this.isActive) {
            return;
        }

        try {
            this.logger.info('正在停用工具...');
            
            // 隐藏工具面板
            this.hidePanel();
            
            // 执行自定义停用逻辑
            await this.onDeactivate();
            
            this.isActive = false;
            this.logger.info('工具已停用');
            
            // 触发停用事件
            this.emit('deactivated');
        } catch (error) {
            this.logger.error('工具停用失败:', error);
            throw error;
        }
    }

    /**
     * 显示工具面板
     */
    showPanel() {
        const panel = document.getElementById(`tool-${this.name}`);
        if (panel) {
            panel.classList.add('active');
        }
    }

    /**
     * 隐藏工具面板
     */
    hidePanel() {
        const panel = document.getElementById(`tool-${this.name}`);
        if (panel) {
            panel.classList.remove('active');
        }
    }

    /**
     * 获取DOM元素
     * 子类应该重写此方法来获取特定的DOM元素
     */
    async getDOMElements() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 设置事件监听器
     * 子类应该重写此方法来设置特定的事件监听器
     */
    setupEventListeners() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 自定义初始化逻辑
     * 子类可以重写此方法来执行特定的初始化逻辑
     */
    async onInitialize() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 自定义激活逻辑
     * 子类可以重写此方法来执行特定的激活逻辑
     */
    async onActivate() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 自定义停用逻辑
     * 子类可以重写此方法来执行特定的停用逻辑
     */
    async onDeactivate() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 获取元素
     * @param {string} id - 元素ID
     * @returns {HTMLElement} DOM元素
     */
    getElement(id) {
        if (!this.elements[id]) {
            this.elements[id] = document.getElementById(id);
        }
        return this.elements[id];
    }

    /**
     * 安全获取元素值
     * @param {string} id - 元素ID
     * @returns {string} 元素值
     */
    getElementValue(id) {
        const element = this.getElement(id);
        return element ? element.value : '';
    }

    /**
     * 安全设置元素值
     * @param {string} id - 元素ID
     * @param {string} value - 要设置的值
     */
    setElementValue(id, value) {
        const element = this.getElement(id);
        if (element) {
            element.value = value;
        }
    }

    /**
     * 显示/隐藏元素
     * @param {string} id - 元素ID
     * @param {boolean} visible - 是否显示
     */
    setElementVisible(id, visible) {
        const element = this.getElement(id);
        if (element) {
            element.style.display = visible ? 'block' : 'none';
        }
    }

    /**
     * 启用/禁用元素
     * @param {string} id - 元素ID
     * @param {boolean} enabled - 是否启用
     */
    setElementEnabled(id, enabled) {
        const element = this.getElement(id);
        if (element) {
            element.disabled = !enabled;
        }
    }

    /**
     * 添加日志
     * @param {string} message - 日志消息
     * @param {string} type - 日志类型
     */
    addLog(message, type = 'info') {
        this.logger.log(message, type);
        
        // 如果有日志容器，也添加到界面上
        const logContainer = this.getElement('logContainer');
        if (logContainer) {
            const logItem = document.createElement('div');
            logItem.className = `log-item log-${type}`;
            logItem.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
            
            logContainer.appendChild(logItem);
            logContainer.scrollTop = logContainer.scrollHeight;
            
            // 限制日志数量
            const logItems = logContainer.children;
            if (logItems.length > 100) {
                logContainer.removeChild(logItems[0]);
            }
        }
    }

    /**
     * 销毁工具
     */
    async destroy() {
        try {
            this.logger.info('正在销毁工具...');
            
            // 如果工具处于激活状态，先停用
            if (this.isActive) {
                await this.deactivate();
            }
            
            // 执行自定义销毁逻辑
            await this.onDestroy();
            
            // 清理DOM元素引用
            this.elements = {};
            
            // 移除所有事件监听器
            this.removeAllListeners();
            
            this.isInitialized = false;
            this.logger.info('工具已销毁');
        } catch (error) {
            this.logger.error('工具销毁失败:', error);
            throw error;
        }
    }

    /**
     * 自定义销毁逻辑
     * 子类可以重写此方法来执行特定的销毁逻辑
     */
    async onDestroy() {
        // 基类实现为空，子类可以重写
    }

    /**
     * 获取工具信息
     * @returns {Object} 工具信息
     */
    getInfo() {
        return {
            name: this.name,
            displayName: this.displayName,
            isActive: this.isActive,
            isInitialized: this.isInitialized
        };
    }
}

module.exports = BaseTool;